// Cookie JAR clock of passion 2020 A3


#include "msp430G2553.h"
#include "math.h"



#define mod_but   BIT0// External buton definitions
#define plus_but  BIT1
#define minus_but BIT2
#define digit1 1   // Digit activation bits definitions
#define digit2 2
#define digit3 3
#define digit4 4
#define digit5 5
#define digit6 6
#define digit7 7
#define DT BIT5       // SP register bits definitions
#define CK BIT4
#define STROBE BIT3
#define RTC_CK BIT0   // RTC bits definitions
#define RTC_DT BIT1
#define digit_on 10000
#define ch0 0x3F      //display char definitions
#define ch1 0x06   // 0000 0110 pgfe dcba
#define ch2 0x5B   // 0101 1011
#define ch3 0x4F
#define ch4 0x66
#define ch5 0x6D
#define ch6 0x7C
#define ch7 0x07
#define ch8 0x7F
#define ch9 0x67   //  0110 0111
#define chA 0x5F   //  0101 1111
#define chB 0x7C   //  0111 1100
#define chC 0x58   //  0101 1000
#define chD 0x5E   //  0101 1110
#define chE 0x7B   //  0111 1011
#define chF 0x71   //  0111 0001
#define chG 0x6F   //  0110 1111
#define chH 0x74   //  0111 0100
#define chI 0x04   //  0000 0100
#define chJ 0x1E   //  0001 1110
#define chK 0x75   //  0111 0101
#define chL 0x38   //  0011 1000
#define chM 0x15   //  0001 0101
#define chN 0x54   //  0101 0100
#define chO 0x5C   //  0101 1100
#define chP 0x73   //  0111 0011
#define chQ 0x67   //  
#define chR 0x50   //  0101 0000
#define chS 0x6D   //  0110 1101
#define chT 0x78   //  0111 1000
#define chU 0x1C   //  0001 1100
#define chV 0x62   //  0110 0010
#define chX 0x52   //  0101 0010
#define chZ 0x5B   //  0101 1011
#define chY 0x6E   //  0110 1110
#define chW 0x2A   //  0010 1010
#define ch_ 0x08   //  0000 1000
#define chd 0x63   //  0110 0011  degree symbol
#define chc 0x39   //  0011 1001  celsius symbol
#define chq 0x80   //  1000 0000  DP used in text
#define clr  0x00  //  0000 0000
#define leds0 0x00 //  0000 0000  LEDs state sequences definition
#define leds1 0xFF //  1111 1111
#define leds2 0x00 //  0000 0000
#define leds3 0xFF //  1111 1111
#define leds4 0x00 //  0001 0000
#define leds5 0xFF //  1111 1111
#define leds6 0x00 //  0000 0000
#define leds7 0xFF //  1111 1111
#define leds8 0x00 //  0000 0000
#define leds9 0xFF //  1111 1111



int ds1,ds2,ds3,ds4,ds5,ds6,ds7,Hz,Hu,Mz,Mu,Sz,Su,secset,minset,hset;
int n,a,k,delay,i,store,buton,store2,logo_count,Int_light,Int_temp;
int array_div_mod[4];
const unsigned char number_chars[10] = {ch0,ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9}; 
const unsigned char led[10] = {leds0,leds1,leds2,leds3,leds4,leds5,leds6,leds7,leds8,leds9};
const unsigned char john_6_35[33] = {clr,clr,clr,clr,chY,chO,chU,clr,chA,chR,chE,clr,chM,chY,clr,chS,chU,chG,chA,chR,clr,chC,chO,chO,chK,chI,chE,clr,clr,clr,clr,clr,clr};
const unsigned char john_8_12[33] = {clr,clr,clr,clr,chY,chO,chU,clr,chA,chR,chE,clr,chM,chY,clr,chH,chO,chN,chE,chY,chB,chU,chN,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr};
const unsigned char john_10_7[33] = {clr,clr,clr,clr,chS,chW,chE,chE,chT,chE,chR,clr,chT,chH,chA,chN,clr,chT,chH,chE,clr,chH,chO,chN,chE,chY,clr,clr,clr,clr,clr,clr,clr};
const unsigned char john_10_11[33]= {clr,clr,clr,clr,chT,chO,clr,chT,chH,chE,clr,chM,chO,chO,chN,clr,chA,chN,chD,clr,chB,chA,chC,chK,clr,clr,clr,clr,clr,clr,clr,clr,clr};
const unsigned char john_11_25[33]= {clr,clr,clr,clr,chT,chO,clr,chM,chY,clr,chB,chE,chL,chO,chV,chE,chD,clr,chS,chW,chE,chE,chT,chH,chE,chA,chR,chT,clr,clr,clr,clr,clr};
const unsigned char john_14_6[33] = {clr,clr,clr,clr,chG,chO,chO,chD,chB,chY,chE,clr,ch2,ch0,ch2,ch0,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr};
const unsigned char john_15_1[33] = {clr,clr,clr,clr,chI,clr,chL,chO,chV,chE,clr,chY,chO,chU,clr,chD,chE,chE,chP,chL,chY,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr};



int delay_time(int);        // delay related
int delay_long(int);

int repeated_start(int);    // RTC related
int slave_addr(int);
int start_condition(int);
int stop_condition(int);
int ACK_bit(int);
int RTC_read(int);
int RTC_write(int);
int write_bit(int);
int go_RTC_addr(int);
int debounce_mod(int);
int debounce_plus(int);
int debounce_minus(int);

int display_digit(int,int); //Clock related
int clock_set(int);
int clock_display(int);
int logo(int);              // Other features
int display_dim(int);


void main(void){
WDTCTL = WDTPW + WDTHOLD; // disable watch dog timer
DCOCTL = CALDCO_16MHZ; // set internal oscillator at 16MHz
BCSCTL1 = CALBC1_16MHZ; // set internal oscillator at 16MHz

P1OUT = 0x00;
P2OUT = 0x00;
P3OUT = 0x07; //0000 0111 keeps RTC reset off and the lines H
P1DIR = 0x38; //0011 1000
P2DIR = 0xFF;
P3DIR = 0xFF;
P3OUT = 0x07;



//--------------------config PWM
P2SEL |= (BIT0);//P2.5 Select as TA1 output                  
TA1CCR0 = 1000;  
TA1CCR1 = 1000;
TA1CCR2 = 1000; 
TA1CCTL0 |= OUTMOD_7; //toggle
TA1CCTL1 |= OUTMOD_7; //toggle 
TA1CCTL2 |= OUTMOD_7; //toggle 
TA1CTL |= TASSEL_2 + MC_1; //smclk div/8 upmode.


delay_long(0);
logo_count = 1;



    for(;;) {      // ===================================================== Main loop ======================================                                                            	

    store2 = P1IN;  // -------------------------------- Clock set loop entry
    buton = (store2 &= mod_but);       
    if(buton == 0 ){  clock_set(0); }
    
   
    store2 = P1IN;  // ----------------------------- Logo display loop entry
    buton = (store2 &= plus_but);       
    if(buton == 0 ){ 
      logo(logo_count); 
    }
    
    
    clock_display(0);
    
    if((Mu + Mz + Su + Sz) == 0){ // ---------- Logo display at certain time
      logo(logo_count); 
    }
    
                    
         }                  // ========================================== Main loop end ======================================           
}






//----------------------------------------------------------------------------------------------------------------------------------
//-----------------  Functions & procedures  -----------  Functions & procedures  -----------  Functions & procedures---------------
//----------------------------------------------------------------------------------------------------------------------------------


int clock_display(int){            // --------------------------------Clock display loop
    RTC_read(0); 
    ds1 = Hz;
    ds2 = Hu;
    ds3 = Mz;
    ds4 = Mu;
    ds5 = Sz;
    ds6 = Su; 
    ds7 = led[Su];
                                   
    display_digit(number_chars[ds1],digit1);              
    display_digit(number_chars[ds2],digit2);             
    display_digit(number_chars[ds3],digit3);         
    display_digit(number_chars[ds4],digit4);                                
    display_digit(number_chars[ds5],digit5);              
    display_digit(number_chars[ds6],digit6);      
    display_digit(ds7,digit7);  
  return (0);
}



int display_dim(int){        // ---------------------------------- Display dimming procedure
  for(a=50;a>1;a--){  
  
//TA1CCR0 = 1000;  
TA1CCR1 = (a*20);
TA1CCR2 = (a*20); 

clock_display(0); 
//adc_read(0);
  }
TA1CCR1 = 1000;
TA1CCR2 = 1000; 
  return (0);
}



int clock_set(int){      //----------------------------------------------- Clock set--------------------
    Su = 0x00;
    Sz = 0x00;
    minset = ((Mz * 10) + Mu);
    hset = ((Hz * 10) + Hu);
    debounce_mod(0);  
    
    do{                   
    store2 = P1IN;
    buton = (store2 &= minus_but); 
    if(buton == 0 ){
    if (minset == 0)minset = 60;
    minset = minset - 1;
    debounce_minus(0);
    }
                  
    store2 = P1IN;
    buton = (store2 &= plus_but); 
    if(buton == 0 ){
    minset = minset + 1;
    if (minset == 60) minset = 0;
    debounce_plus(0);
    }
                             
    i=7; 
    store = minset;
    Mz = 0x00;
    Mu = 0x00;
    do{                   //  div/mod loop
      if (store >= 10){
      store = store - 10;  
      Mz = Mz + 1;
      }
      i--;
    }while(i != 0);
    Mu = store;
    
    ds3 = Mz;
    ds4 = Mu;
    ds6 = chT;
              
    display_digit(number_chars[ds3],digit3);
    display_digit(number_chars[ds4],digit4);                  
    display_digit(ds6,digit6);
    
    store2 = P1IN;
    buton = (store2 &= mod_but);                    
    }while(buton != 0 );
    
    debounce_mod(0);
    do{    
      
    store2 = P1IN;
    buton = (store2 &= minus_but); 
    if(buton == 0 ){
    if (hset == 0)hset = 24;
    hset = hset - 1;
    debounce_minus(0);
    }
    
    store2 = P1IN;
    buton = (store2 &= plus_but); 
    if(buton == 0 ){
    hset = hset + 1;
    if (hset == 24) hset = 0;
    debounce_plus(0);
    }
     
    i=7; 
    store = hset;
    Hz = 0x00;
    Hu = 0x00;
    do{                   //  div/mod loop
      if (store >= 10){
      store = store - 10;  
      Hz = Hz + 1;
      }
      i--;
    }while(i != 0);
    Hu = store;
    
    ds1 = Hz;
    ds2 = Hu; 
    ds6 = chT;
             
    display_digit(number_chars[ds1],digit1);               
    display_digit(number_chars[ds2],digit2);             
    display_digit(ds6,digit6);
    
    store2 = P1IN;
    buton = (store2 &= mod_but);                    
    }while(buton != 0 );
    debounce_mod(0);
    RTC_write(0);                
return (0);
}



int RTC_read(int){      //------------------------------------------------ RTC_read---------------------

Sz = 0x00;
Su = 0x00;
Mz = 0x00;
Mu = 0x00;
Hz = 0x00;
Hu = 0x00;
  
  P3DIR = 0xFF;  //1111 1111 //DT in write mode  
  delay_time(10);
  start_condition(0);
  slave_addr(0);  
  write_bit(0);  // R/W bit is tet to Write
  ACK_bit(0);
  go_RTC_addr(0x00);
  ACK_bit(0);
  repeated_start(0);
  slave_addr(0);  
  write_bit(1);    // R/W bit is set to read
  ACK_bit(0);
  
  P3DIR = 0xFD;  //1111 1101 //DT in read mode
  delay_time(10);

  
  i = 4;
  do{
  Sz = Sz << 1;
  P3OUT |= RTC_CK;     
  delay_time(10);
  Sz &= 0xFE;  
  if ((P3IN & 0x02) > 0) Sz |= 0x01;
  P3OUT &= ~(RTC_CK); 
  delay_time(10);
  i--;
  }while (i!=0);
  
  i = 4;
  do{
  Su = Su << 1;
  P3OUT |= RTC_CK;     
  delay_time(10);
  Su &= 0xFE;  
  if ((P3IN & 0x02) > 0) Su |= 0x01;
  P3OUT &= ~(RTC_CK); 
  delay_time(10);
  i--;
  }while (i!=0);
  
  P3DIR = 0xFF;  //1111 1111 //DT in write mode  
  write_bit(0);
  P3DIR = 0xFD;  //1111 1101 //DT in read mode  
   
  i = 4;
  do{
  Mz = Mz << 1;
  P3OUT |= RTC_CK;     
  delay_time(10);
  Mz &= 0xFE;  
  if ((P3IN & 0x02) > 0) Mz |= 0x01;
  P3OUT &= ~(RTC_CK); 
  delay_time(10);
  i--;
  }while (i!=0);
  
  i = 4;
  do{
  Mu = Mu << 1;
  P3OUT |= RTC_CK;     
  delay_time(10);
  Mu &= 0xFE;  
  if ((P3IN & 0x02) > 0) Mu |= 0x01;
  P3OUT &= ~(RTC_CK); 
  delay_time(10);
  i--;
  }while (i!=0);

  P3DIR = 0xFF;  //1111 1111 //DT in write mode  
  write_bit(0);
  P3DIR = 0xFD;  //1111 1101 //DT in read mode  
   
  i = 4;
  do{
  Hz = Hz << 1;
  P3OUT |= RTC_CK;     
  delay_time(10);
  Hz &= 0xFE;  
  if ((P3IN & 0x02) > 0) Hz |= 0x01;
  P3OUT &= ~(RTC_CK); 
  delay_time(10);
  i--;
  }while (i!=0);
  
  i = 4;
  do{
  Hu = Hu << 1;
  P3OUT |= RTC_CK;     
  delay_time(10);
  Hu &= 0xFE;  
  if ((P3IN & 0x02) > 0) Hu |= 0x01;
  P3OUT &= ~(RTC_CK); 
  delay_time(10);
  i--;
  }while (i!=0); 

  ACK_bit(0);
  stop_condition(0);  
return(0);
}



int RTC_write(int){      //------------------------------------------------ RTC_write--------------------
  
  P3DIR = 0xFF;  //1111 1111 //DT in write mode  
  delay_time(10);
  start_condition(0);
  slave_addr(0);  
  write_bit(0);  // R/W bit is tet to Write
  ACK_bit(0);
  go_RTC_addr(0x00);
  ACK_bit(0);
  
  i = 4;
  do{
  P3OUT &= ~(RTC_DT); 
  if ((Sz & 0x08) > 0) P3OUT |= RTC_DT;
  P3OUT |= RTC_CK;     
  delay_time(10); 
  P3OUT &= ~(RTC_CK); 
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  Sz = Sz << 1;
  i--;
  }while (i!=0);
  
  i = 4;
  do{
  P3OUT &= ~(RTC_DT); 
  if ((Su & 0x08) > 0) P3OUT |= RTC_DT;
  P3OUT |= RTC_CK;     
  delay_time(10); 
  P3OUT &= ~(RTC_CK); 
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  Su = Su << 1;
  i--;
  }while (i!=0);
  
  write_bit(0);
   
  i = 4;
  do{
  P3OUT &= ~(RTC_DT); 
  if ((Mz & 0x08) > 0) P3OUT |= RTC_DT;
  P3OUT |= RTC_CK;     
  delay_time(10); 
  P3OUT &= ~(RTC_CK); 
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  Mz = Mz << 1;
  i--;
  }while (i!=0);
  
  i = 4;
  do{
  P3OUT &= ~(RTC_DT); 
  if ((Mu & 0x08) > 0) P3OUT |= RTC_DT;
  P3OUT |= RTC_CK;     
  delay_time(10); 
  P3OUT &= ~(RTC_CK); 
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  Mu = Mu << 1;
  i--;
  }while (i!=0);
 
  write_bit(0); 
   
  i = 4;
  do{
  P3OUT &= ~(RTC_DT); 
  if ((Hz & 0x08) > 0) P3OUT |= RTC_DT;
  P3OUT |= RTC_CK;     
  delay_time(10); 
  P3OUT &= ~(RTC_CK); 
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  Hz = Hz << 1;
  i--;
  }while (i!=0);
  
  i = 4;
  do{
  P3OUT &= ~(RTC_DT); 
  if ((Hu & 0x08) > 0) P3OUT |= RTC_DT;
  P3OUT |= RTC_CK;     
  delay_time(10); 
  P3OUT &= ~(RTC_CK); 
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  Hu = Hu << 1;
  i--;
  }while (i!=0);

  ACK_bit(0);
  stop_condition(0);  
return(0);
}



int start_condition(int){      //------------------------------------RTC start condition---------------------
  delay_time(10);   
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  P3OUT &= ~(RTC_CK);  
  delay_time(10);
return (0);
}



int stop_condition(int){      //-------------------------------------RTC stop condition---------------------
  delay_time(10);
  P3OUT |= RTC_CK; 
  delay_time(10);
  P3OUT |= RTC_DT; 
  delay_time(10);
return (0);
}



int write_bit(int bit_val){      //-------------------------------------RTC Write bit---------------------
  if (bit_val == 0){
  P3OUT &= ~(RTC_DT); }
  else{
  P3OUT |= RTC_DT; 
  }
  P3OUT |= RTC_CK; 
  delay_time(10);
  P3OUT &= ~(RTC_CK);   
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
return (0);
}



int slave_addr(int){      //------------------------------------------RTC slave address--------------------
  i=2;
  do{
  P3OUT |= RTC_DT;   // Slave address 11
  P3OUT |= RTC_CK; 
  delay_time(10);
  P3OUT &= ~(RTC_CK);   
  P3OUT &= ~(RTC_DT);  
  i--;
  delay_time(10);
  }while (i!=0);

  P3OUT &= ~(RTC_DT);   // Slave address 0
  P3OUT |= RTC_CK; 
  delay_time(10);
  P3OUT &= ~(RTC_CK);   
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  
  P3OUT |= RTC_DT;  // Slave address 1
  P3OUT |= RTC_CK; 
  delay_time(10);
  P3OUT &= ~(RTC_CK);   
  P3OUT &= ~(RTC_DT); 
   delay_time(10);

  i=3;
  do{
  P3OUT &= ~(RTC_DT);   // Slave address 000
  P3OUT |= RTC_CK; 
  delay_time(10);
  P3OUT &= ~(RTC_CK);   
  P3OUT &= ~(RTC_DT);  
  i--;
  delay_time(10);
  }while (i!=0);
return (0);
}



int repeated_start(int){      //--------------------------------------RTC repeated start---------------------
  P3OUT |= RTC_DT;  
  delay_time(10);
  P3OUT |= RTC_CK;  
  delay_time(10);
  P3OUT &= ~(RTC_DT); 
  delay_time(10);  
  P3OUT &= ~(RTC_CK);
  delay_time(10);
return (0);
}



int ACK_bit(int){      //-------------------------------------------------RTC ACK bit---------------------
  P3DIR = 0xFD;  //1111 1101 //DT in read mode
  P3OUT |= RTC_CK;    //ACK bit
  delay_time(30);
  // if DT = 0 ...test bit
  P3OUT &= ~(RTC_CK); 
  P3DIR = 0xFF;  //1111 1111 //DT in write mode  
  delay_time(10);
return (0);
}



int go_RTC_addr(int addr){      //-------------------------------Go to speciffic RTC address---------------------
  P3OUT &= ~(RTC_DT); 
  i=8;
  do{
  if ((addr & 0x80) != 0) P3OUT |= RTC_DT; 
  P3OUT |= RTC_CK; 
  delay_time(10);
  P3OUT &= ~(RTC_CK);   
  P3OUT &= ~(RTC_DT);  
  addr = addr << 1;
  i--;
  delay_time(10);
  }while (i!=0);    
return (0);
}



int delay_time (int delay){      //----------------------------------------- Delay---------------------
  do delay--;
  while (delay != 0);
return (int)(delay);
}



int delay_long (int){            //--------------------------------------- Delay long------------------
  int j;                   
  j = 100;
  do{	
  delay_time(5000);
  j--;
  }while (j != 0);        
return (0);
}



int debounce_mod(int){      //------------------------------------- Debounce the mod button--------------------
 do{                 
 store2 = P1IN;
 buton = (store2 &= mod_but);
 delay_time(1000);
 }while (buton == 0);
return (0);
}



int debounce_minus(int){      //----------------------------------- Debounce the minus button--------------------
 do{                 
 store2 = P1IN;
 buton = (store2 &= minus_but);
 delay_time(1000);
 }while (buton == 0);
return (0);
}



int debounce_plus(int){      //------------------------------------ Debounce the plus button--------------------
 do{                 
 store2 = P1IN;
 buton = (store2 &= plus_but);
 delay_time(1000);
 }while (buton == 0);
return (0);
}



int display_digit(int w_char,int digit){  //------------------------------ Display digit ------------------------
int str;

P2OUT = 0x00;  
str = w_char; 
//---------------------------------------register load  
  
  if ((str & 0x80) != 0){  //Write str bit7 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT); 
  
  if ((str & 0x40) != 0){  //Write str bit6 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT);
  
  if ((str & 0x20) != 0){  //Write str bit5 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT); 
  
  if ((str & 0x10) != 0){  //Write str bit4 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT);
  
  if ((str & 0x08) != 0){  //Write str bit3 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT); 
  
  if ((str & 0x04) != 0){  //Write str bit2 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT);
  
  if ((str & 0x02) != 0){  //Write str bit1 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT);
  
  if ((str & 0x01) != 0){  //Write str bit0 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT);
  
  P1OUT |= STROBE;
  delay_time(10);
  P1OUT &= ~(STROBE); 
  
  if (digit == 1){
  P2SEL  |= (0x02);//P2.5 Select as TA1 output 
  delay_time(digit_on);
  P2SEL = 0x00; 
  }
  if (digit == 2){
  P2SEL  |= (0x04);//P2.5 Select as TA1 output 
  delay_time(digit_on);
  P2SEL = 0x00; 
  }
  if (digit == 3){
  P2SEL  |= (0x10);//P2.5 Select as TA1 output 
  delay_time(digit_on);
  P2SEL = 0x00; 
  }
  if (digit == 4){
  P2SEL  |= (0x20);//P2.5 Select as TA1 output 
  delay_time(digit_on);
  P2SEL = 0x00; 
  }
  if (digit == 7){
  P2SEL  |= (0x08);//P2.5 Select as TA1 output 
  delay_time(digit_on);
  P2SEL = 0x00; 
  }  
  
return(0);      
}   



int logo(int message){             // ---------------------------------- Displaying Logos
  display_dim(0);  
  
  for(a=0;a<27;a++){
    for(n=0;n<20;n++){  //n is the reversed constant of transition speed
      for(k=0;k<6;k++){
        if ( message == 1 ){    
          display_digit(john_6_35[k+a],(k+1)); }     
        if ( message == 2 ){    
          display_digit(john_8_12[k+a],(k+1)); }  
        if ( message == 3 ){    
          display_digit(john_10_7[k+a],(k+1)); }     
        if ( message == 4 ){    
          display_digit(john_10_11[k+a],(k+1)); }
        if ( message == 5 ){    
          display_digit(john_11_25[k+a],(k+1)); }  
        if ( message == 6 ){    
          display_digit(john_14_6[k+a],(k+1)); }     
        if ( message == 7 ){    
          display_digit(john_15_1[k+a],(k+1)); }
      }
    display_digit(led[0],digit7);  
    }
  }
      logo_count ++;
      if(logo_count > 7){
      logo_count = 0x01; 
      }
return(0);  
}



float bucla_div_mod(float ref_temp_val){   //---------------------------- Loop for div/mod ------------
unsigned char j;
  
for(i=0; i<4; i++){
array_div_mod[i] = 0x00;          
}
    for(j=0; j<4; j++){ 
     if(j > 0){ 
     ref_temp_val = ref_temp_val*10;
     }
     for(i=0; i<10; i++){
     if ( ref_temp_val >= 10 ){
     ref_temp_val = ref_temp_val - 10;
     array_div_mod[j] ++;
     }
     } 
    }
         
return (int)(array_div_mod);                     
}